package com.tankbattle.view;

import com.tankbattle.controller.GameKeyListener;
import com.tankbattle.model.*;
import com.tankbattle.util.ImageManager;

import javax.swing.JPanel;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 游戏面板类，继承自JPanel，实现Runnable接口用于游戏循环
 */
public class GamePanel extends JPanel implements Runnable {
    
    // 屏幕尺寸，将在构造函数中初始化为全屏尺寸
    public static int WIDTH;
    public static int HEIGHT;

    // 游戏主循环线程
    private Thread gameThread;
    private volatile boolean running = false;

    // 游戏状态
    public enum GameState {
        MENU, PLAYING, GAME_OVER, WIN
    }
    private GameState gameState = GameState.MENU;

    // 游戏对象列表
    private List<Tank> tanks = new CopyOnWriteArrayList<>();
    private List<Bullet> bullets = new CopyOnWriteArrayList<>();
    private List<Wall> walls = new CopyOnWriteArrayList<>();
    private List<Terrain> terrains = new CopyOnWriteArrayList<>();
    private List<Explosion> explosions = new CopyOnWriteArrayList<>();

    // 玩家坦克
    private Tank playerTank;

    // 游戏统计
    private int score = 0;
    private int enemyCount = 0;
    private int maxEnemies = 10;
    private int enemiesDestroyed = 0;

    // 随机数生成器
    private Random random = new Random();

    // 键盘监听器
    private GameKeyListener keyListener;

    // 背景图片
    private BufferedImage backgroundImage;

    /**
     * 构造函数
     */
    public GamePanel() {
        // 获取屏幕尺寸
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        WIDTH = screenSize.width;
        HEIGHT = screenSize.height;

        // 设置面板的首选大小
        setPreferredSize(new Dimension(WIDTH, HEIGHT));


        // 加载背景图片
        backgroundImage = ImageManager.getInstance().getImage("background.jpg");
        if (backgroundImage == null) {
            System.err.println("无法加载背景图片: background.jpg");
        } else {
            System.out.println("成功加载背景图片");
        }

        // 设置面板可以获得焦点，这样才能接收键盘事件
        setFocusable(true);

        // 创建并添加键盘监听器
        keyListener = new GameKeyListener(this);
        addKeyListener(keyListener);

        // 初始化游戏
        initGame();

        // 设置初始游戏状态为 PLAYING
        gameState = GameState.PLAYING;
    }

    /**
     * 初始化游戏，创建对象等
     */
    public void initGame() {
        // 重置游戏状态
        score = 0;
        enemyCount = 0;
        enemiesDestroyed = 0;

        // 清空游戏对象列表
        tanks.clear();
        bullets.clear();
        explosions.clear();

        // 创建玩家坦克
        playerTank = new Tank(WIDTH / 2 - 32, HEIGHT - 100, Direction.UP, true);
        tanks.add(playerTank);

        // 创建地图
        createMap();
    }

    /**
     * 创建游戏地图
     */
    private void createMap() {
        // 清空现有地��元素
        walls.clear();
        terrains.clear();

        // 创建边界墙
        createBoundaryWalls();

        // 创建随机障碍物
        createRandomObstacles();
    }

    /**
     * 创建边界墙
     */
    private void createBoundaryWalls() {
        // 创建不可摧毁的边界墙
        for (int x = 0; x < WIDTH; x += 32) {
            // 上边界
            walls.add(new Wall(x, 0, false));
            // 下边界
            walls.add(new Wall(x, HEIGHT - 32, false));
        }

        for (int y = 32; y < HEIGHT - 32; y += 32) {
            // 左边界
            walls.add(new Wall(0, y, false));
            // 右边界
            walls.add(new Wall(WIDTH - 32, y, false));
        }
    }

    /**
     * 创建随机障碍物
     */
    private void createRandomObstacles() {
        int numObstacles = WIDTH * HEIGHT / 25000; // 总障碍物数量
        int numSteelWalls = numObstacles / 3;      // 钢墙数量为总数的1/3

        // 先生成钢墙（不可摧毁的墙��
        for (int i = 0; i < numSteelWalls; i++) {
            createObstacle(false); // false 表示创建不可摧毁的钢墙
        }

        // 生成普通墙（可摧毁的墙）
        for (int i = 0; i < numObstacles - numSteelWalls; i++) {
            createObstacle(true);  // true 表示创建可��毁的普通墙
        }
    }

    private void createObstacle(boolean breakable) {
        int maxAttempts = 100; // 最大尝试次数
        int attempts = 0;

        while (attempts < maxAttempts) {
            int x = 32 + random.nextInt((WIDTH - 96) / 32) * 32;
            int y = 32 + random.nextInt((HEIGHT - 160) / 32) * 32;

            // 检查是否与玩家坦克位置冲突
            Rectangle playerArea = new Rectangle(playerTank.getX() - 128, playerTank.getY() - 128, 300, 300);
            Rectangle obstacleArea = new Rectangle(x, y, 32, 32);

            if (!playerArea.intersects(obstacleArea)) {
                boolean validPosition = true;

                // 检查是否与其他墙壁重叠
                for (Wall wall : walls) {
                    Rectangle wallArea = new Rectangle(wall.getX() - 32, wall.getY() - 32, 96, 96);
                    if (wallArea.intersects(obstacleArea)) {
                        validPosition = false;
                        break;
                    }
                }

                // 检查是否会阻塞坦克生成点
                for (int[] spawnPoint : new int[][]{{64, 64}, {WIDTH - 128, 64}, {WIDTH / 2, 64}}) {
                    Rectangle spawnArea = new Rectangle(spawnPoint[0] - 64, spawnPoint[1] - 64, 128, 128);
                    if (spawnArea.intersects(obstacleArea)) {
                        validPosition = false;
                        break;
                    }
                }

                if (validPosition) {
                    walls.add(new Wall(x, y, breakable));
                    return;
                }
            }

            attempts++;
        }
    }

    /**
     * 启动游戏线程
     */
    public void startGameLoop() {
        if (gameThread == null) {
            running = true;
            gameThread = new Thread(this);
            gameThread.start();
        }
    }

    /**
     * 停止游戏线程
     */
    public void stopGameLoop() {
        running = false;
        try {
            if (gameThread != null) {
                gameThread.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 游戏主循环方法
     */
    @Override
    public void run() {
        // 游戏循环常用变量
        long lastTime = System.nanoTime();
        final double nsPerTick = 1000000000.0 / 60.0; // 每帧需要的时间（纳秒），目标60FPS
        double delta = 0;
        long timer = System.currentTimeMillis();
        int frames = 0;
        int updates = 0;

        // 请求焦点，确保能接收键盘输入
        requestFocus();

        while (running) {
            long now = System.nanoTime();
            delta += (now - lastTime) / nsPerTick;
            lastTime = now;

            boolean shouldRender = false;

            // 以固定的频率更新游戏逻辑
            while (delta >= 1) {
                updateGame();
                updates++;
                delta -= 1;
                shouldRender = true;
            }

            // 渲染游戏画面
            if (shouldRender) {
                renderGame();
                frames++;
            }

            // 简单的休眠以防止CPU占用过高
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
                running = false;
                Thread.currentThread().interrupt();
            }

            // 每秒打印一次FPS和UPS
            if (System.currentTimeMillis() - timer >= 1000) {
                timer += 1000;
                System.out.println("FPS: " + frames + ", UPS: " + updates);
                frames = 0;
                updates = 0;

                // 每秒尝试生成敌人
                if (gameState == GameState.PLAYING) {
                    spawnEnemies();
                }
            }
        }
    }

    /**
     * 生成敌���坦克
     */
    private void spawnEnemies() {
        if (enemyCount < 5 && enemiesDestroyed < maxEnemies) {
            // 定义可能的出生��
            int[][] spawnPoints = {
                {64, 64},           // 左上角
                {WIDTH - 128, 64},  // 右上角
                {WIDTH / 2, 64},    // 上中
            };

            // 尝试在不同位置生成坦克
            for (int[] point : spawnPoints) {
                int x = point[0];
                int y = point[1];

                // 检查位置是否合适
                if (isValidSpawnPosition(x, y)) {
                    // 创建敌人坦克
                    Tank enemyTank = new Tank(x, y, Direction.DOWN, false);
                    tanks.add(enemyTank);
                    enemyCount++;
                    return; // 成功生成一个坦克后返回
                }
            }
        }
    }

    /**
     * 检查是否是有效的坦克生成位置
     */
    private boolean isValidSpawnPosition(int x, int y) {
        // 创建一个矩形表示新坦克的位置，考虑缩小后的坦克大小
        Rectangle newTankArea = new Rectangle(x, y, 48, 48);

        // 检查与其他坦克的碰撞
        for (Tank tank : tanks) {
            if (tank.isActive()) {
                Rectangle existingTankArea = new Rectangle(tank.getX(), tank.getY(), 48, 48);
                // 扩大检查范围，确保坦克之间有足够空间
                existingTankArea.grow(48, 48);
                if (existingTankArea.intersects(newTankArea)) {
                    return false;
                }
            }
        }

        // 检查与墙壁的碰撞，增加安全距离
        for (Wall wall : walls) {
            if (wall.isActive()) {
                Rectangle wallArea = new Rectangle(wall.getX() - 16, wall.getY() - 16, 64, 64);
                if (wallArea.intersects(newTankArea)) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * 更新敌人AI行为
     */
    private void updateEnemyAI(Tank enemyTank) {
        // 增加改变方向的概率，使敌方坦克更活跃
        if (random.nextInt(100) < 5) { // 5%的概率改变方向
            int dirValue = random.nextInt(4);
            Direction newDir = Direction.values()[dirValue];
            enemyTank.setDirection(newDir);
        }

        // 让敌方坦克始终保持移动状态
        enemyTank.setMoving(true);

        // 随机开火
        if (random.nextInt(100) < 3) { // 3%的概率开火
            Bullet bullet = enemyTank.fire();
            if (bullet != null) {
                bullets.add(bullet);
            }
        }
    }

    /**
     * 更新游戏状态
     */
    private void updateGame() {
        if (gameState == GameState.PLAYING) {
            // 更新坦克
            updateTanks();

            // 更新子弹
            updateBullets();

            // 更新爆炸效果
            updateExplosions();

            // 检查游戏结束条件
            checkGameOver();
        }
    }

    /**
     * 更新坦克状态
     */
    private void updateTanks() {
        for (Tank tank : tanks) {
            if (tank.isActive()) {
                // 更新坦克状态
                tank.update(0);

                // 检查坦克是否超出屏幕边界
                tank.checkBounds(WIDTH, HEIGHT);

                // 检查坦克与墙壁的碰撞
                checkTankWallCollision(tank);

                // 检查坦克与地形的碰撞
                checkTankTerrainCollision(tank);

                // 检查坦克与坦克的碰撞
                checkTankTankCollision(tank);

                // 敌人AI行为
                if (!tank.isPlayer()) {
                    updateEnemyAI(tank);
                }
            }
        }
    }

    /**
     * 检查坦克与墙壁的碰撞
     */
    private void checkTankWallCollision(Tank tank) {
        for (Wall wall : walls) {
            if (wall.isActive() && tank.intersects(wall)) {
                tank.revertPosition();
                break;
            }
        }
    }

    /**
     * 检查坦克与地形的碰撞
     */
    private void checkTankTerrainCollision(Tank tank) {
        // 移除水和草地的碰撞检测，让坦克可以自由通过
        // 注意：这里可以添加一些视觉效果，比如穿过水面时的涟漪效果等
        return;
    }

    /**
     * 检查坦克与坦克的碰撞
     */
    private void checkTankTankCollision(Tank tank) {
        for (Tank otherTank : tanks) {
            if (otherTank != tank && otherTank.isActive() && tank.intersects(otherTank)) {
                tank.revertPosition();
                break;
            }
        }
    }

    /**
     * 更新��弹状态
     */
    private void updateBullets() {
        for (int i = bullets.size() - 1; i >= 0; i--) {
            Bullet bullet = bullets.get(i);

            if (bullet.isActive()) {
                // 更新子弹位置
                bullet.update(0);

                // 检查子弹是否超出屏幕边界
                if (bullet.isOutOfBounds(WIDTH, HEIGHT)) {
                    bullet.setActive(false);
                    bullets.remove(i);
                    continue;
                }

                // 检查子弹与墙壁的碰撞
                if (checkBulletWallCollision(bullet)) {
                    bullet.setActive(false);
                    bullets.remove(i);
                    continue;
                }

                // 检查子弹与坦克的碰撞
                if (checkBulletTankCollision(bullet)) {
                    bullet.setActive(false);
                    bullets.remove(i);
                    continue;
                }

                // 检查子弹与子弹的碰撞
                if (checkBulletBulletCollision(bullet)) {
                    bullet.setActive(false);
                    bullets.remove(i);
                    continue;
                }
            } else {
                bullets.remove(i);
            }
        }
    }

    /**
     * 检查子弹与墙壁的碰撞
     */
    private boolean checkBulletWallCollision(Bullet bullet) {
        for (Wall wall : walls) {
            if (wall.isActive() && bullet.intersects(wall)) {
                // 如果墙是可摧毁的，则摧毁墙
                if (wall.isBreakable()) {
                    wall.setActive(false);
                    // 创建爆炸效果
                    explosions.add(new Explosion(wall.getX(), wall.getY()));
                }
                return true;
            }
        }
        return false;
    }

    /**
     * 检查子弹与坦克的碰撞
     */
    private boolean checkBulletTankCollision(Bullet bullet) {
        for (Tank tank : tanks) {
            if (tank.isActive() && bullet.intersects(tank)) {
                // 玩家子弹不能伤害玩家，敌人子弹不能伤害敌人
                if (bullet.isFromPlayer() == tank.isPlayer()) {
                    continue;
                }

                // 坦克受到伤害
                boolean destroyed = tank.takeDamage();

                // 创建爆炸效果
                explosions.add(new Explosion(bullet.getX() - 8, bullet.getY() - 8));

                // 如果坦克被摧毁
                if (destroyed) {
                    // 增加分数
                    if (!tank.isPlayer()) {
                        score += 100;
                        enemiesDestroyed++;
                        enemyCount--;
                    }

                    // 创建爆炸效果
                    explosions.add(new Explosion(tank.getX() - 16, tank.getY() - 16));

                    // 移除坦克
                    tank.setActive(false);
                }
                return true;
            }
        }
        return false;
    }

    /**
     * 检查子弹与子弹的碰撞
     */
    private boolean checkBulletBulletCollision(Bullet bullet) {
        for (Bullet otherBullet : bullets) {
            if (otherBullet != bullet && otherBullet.isActive() && bullet.intersects(otherBullet)) {
                // 创建爆炸效果
                explosions.add(new Explosion(bullet.getX() - 8, bullet.getY() - 8));
                otherBullet.setActive(false);
                return true;
            }
        }
        return false;
    }

    /**
     * 更新爆炸效果
     */
    private void updateExplosions() {
        for (int i = explosions.size() - 1; i >= 0; i--) {
            Explosion explosion = explosions.get(i);
            if (explosion.isActive()) {
                explosion.update(0);
            } else {
                explosions.remove(i);
            }
        }
    }

    /**
     * 检查游戏结束条件
     */
    private void checkGameOver() {
        if (!playerTank.isActive()) {
            gameState = GameState.GAME_OVER;
        } else if (enemiesDestroyed >= maxEnemies) {
            gameState = GameState.WIN;
        }
    }

    /**
     * 渲染游戏画面
     */
    private void renderGame() {
        repaint();  // 使用 Swing 的标准重绘机制，它会自动调用 paintComponent
    }

    /**
     * 渲染游戏对象
     */
    private void renderObjects(Graphics2D g2d) {
        // 先绘制地形
        for (Terrain terrain : terrains) {
            if (terrain.isActive()) {
                terrain.draw(g2d);
            }
        }

        // 然后绘制墙壁
        for (Wall wall : walls) {
            if (wall.isActive()) {
                wall.draw(g2d);
            }
        }

        // 绘制子弹
        for (Bullet bullet : bullets) {
            if (bullet.isActive()) {
                bullet.draw(g2d);
            }
        }

        // 绘制坦克
        for (Tank tank : tanks) {
            if (tank.isActive()) {
                tank.draw(g2d);
            }
        }

        // 最后绘制爆炸效果（应该在最上层）
        for (Explosion explosion : explosions) {
            if (explosion.isActive()) {
                explosion.draw(g2d);
            }
        }
    }

    /**
     * 渲染��戏状态
     */
    private void renderGameState(Graphics2D g2d) {

        g2d.setFont(new Font("Arial", Font.BOLD, 24));

        switch (gameState) {
            case MENU:
                g2d.drawString("Press ENTER to Start", WIDTH / 2 - 100, HEIGHT / 2);
                break;
            case GAME_OVER:
                g2d.drawString("Game Over", WIDTH / 2 - 50, HEIGHT / 2);
                g2d.drawString("Press ENTER to Restart", WIDTH / 2 - 100, HEIGHT / 2 + 30);
                break;
            case WIN:
                g2d.drawString("You Win!", WIDTH / 2 - 50, HEIGHT / 2);
                g2d.drawString("Press ENTER to Restart", WIDTH / 2 - 100, HEIGHT / 2 + 30);
                break;
        }

        // 渲染分数
        g2d.drawString("Score: " + score, 10, 30);
    }

    /**
     * 获取当前游戏状态
     * @return 当前游戏状态
     */
    public GameState getGameState() {
        return gameState;
    }

    /**
     * 设置游戏状态
     * @param state 要设置的游戏状态
     */
    public void setGameState(GameState state) {
        this.gameState = state;
    }

    /**
     * 获取玩家坦克
     * @return 玩家坦克对象
     */
    public Tank getPlayerTank() {
        return playerTank;
    }

    /**
     * 添加子弹
     * @param bullet 要添加的子弹
     */
    public void addBullet(Bullet bullet) {
        if (bullet != null) {
            bullets.add(bullet);
        }
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;

        // 启用抗锯齿
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        // 始终绘制背景图片作为最底层
        if (backgroundImage != null) {
            g2d.drawImage(backgroundImage, 0, 0, getWidth(), getHeight(), null);
        }

        // 根据游戏状态绘制不同的内容
        switch (gameState) {
            case MENU:
                drawMenu(g2d);
                break;
            case PLAYING:
                // 只绘制游戏对象和HUD，不重复绘制背景
                renderObjects(g2d);
                drawHUD(g2d);
                break;
            case GAME_OVER:
                // 只绘制游戏对象和结束画面，不重复绘制背景
                renderObjects(g2d);
                drawGameOver(g2d);
                break;
            case WIN:
                // 只绘制游戏对象和胜利画面，不重复绘制背景
                renderObjects(g2d);
                drawWin(g2d);
                break;
        }
    }

    private void drawMenu(Graphics2D g) {

        g.setFont(new Font("微软雅黑", Font.BOLD, 48));
        String title = "坦克大战";
        g.drawString(title, WIDTH / 2 - 120, HEIGHT / 2 - 60);

        g.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        String startPrompt = "按回车键开始游戏";
        g.drawString(startPrompt, WIDTH / 2 - 120, HEIGHT / 2);

        g.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        String exitPrompt = "按Q键退出游戏";
        g.drawString(exitPrompt, WIDTH / 2 - 90, HEIGHT / 2 + 40);
    }

    private void drawGame(Graphics2D g) {
        // 只绘制游戏对象和信息，背景已经在 paintComponent 中绘制
        renderObjects(g);

        // 绘制游戏信���
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑", Font.BOLD, 20));
        g.drawString("分数: " + score, 20, 30);
        String enemyText = String.format("剩余敌人: %d", (maxEnemies - enemiesDestroyed));
        g.drawString(enemyText, 20, 60);
    }

    private void drawGameOver(Graphics2D g) {
        // 半透明黑色背景
        g.setColor(new Color(0, 0, 0, 180));
        g.fillRect(0, 0, WIDTH, HEIGHT);

        g.setColor(Color.RED);
        g.setFont(new Font("微软雅黑", Font.BOLD, 48));
        String gameOver = "游戏结束!";
        g.drawString(gameOver, WIDTH / 2 - 120, HEIGHT / 2 - 20);


        g.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        String restart = "按回车键重新开始";
        g.drawString(restart, WIDTH / 2 - 120, HEIGHT / 2 + 30);
        String exitPrompt = "按Q键退出游戏";
        g.drawString(exitPrompt, WIDTH / 2 - 90, HEIGHT / 2 + 70);
    }

    private void drawWin(Graphics2D g) {
        // 半透明黑色背景
        g.setColor(new Color(0, 0, 0, 180));
        g.fillRect(0, 0, WIDTH, HEIGHT);

        g.setColor(Color.GREEN);
        g.setFont(new Font("微软雅黑", Font.BOLD, 48));
        String victory = "胜利!";
        g.drawString(victory, WIDTH / 2 - 80, HEIGHT / 2 - 20);


        g.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        String restart = "按回车键重新开始";
        g.drawString(restart, WIDTH / 2 - 120, HEIGHT / 2 + 30);
        String exitPrompt = "按Q键退出游戏";
        g.drawString(exitPrompt, WIDTH / 2 - 90, HEIGHT / 2 + 70);
    }

    private void drawHealthBars(Graphics2D g) {
        // 启用抗锯齿
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        // 遍历所有坦克绘制血条
        for (Tank tank : tanks) {
            if (tank.isActive()) {
                // ���家坦克和敌方坦��使用不同大小的血条
                int barWidth = tank.isPlayer() ? 80 : 40;
                int barHeight = tank.isPlayer() ? 10 : 5;
                int borderSize = tank.isPlayer() ? 2 : 1;

                // 玩家血条显示在屏幕顶部���定位��，敌人血条显示在坦克上方
                int x, y;
                if (tank.isPlayer()) {
                    x = 20;
                    y = 20;
                } else {
                    x = tank.getX() + (tank.getWidth() - barWidth) / 2;
                    y = tank.getY() - 10;
                }

                // 绘制血条外边框（黑色）
                g.setColor(Color.BLACK);
                g.fillRect(x - borderSize, y - borderSize,
                          barWidth + borderSize * 2, barHeight + borderSize * 2);

                // 绘制血条背景（深红色）
                g.setColor(new Color(139, 0, 0));
                g.fillRect(x, y, barWidth, barHeight);

                // 绘制当前血量
                float healthRatio = (float)tank.getHealth() / tank.getMaxHealth();
                int currentWidth = (int)(barWidth * healthRatio);

                // 根据血量百分比改变颜色
                if (healthRatio > 0.6f) {
                    g.setColor(new Color(0, 255, 0)); // ���色
                } else if (healthRatio > 0.3f) {
                    g.setColor(new Color(255, 255, 0)); // 黄色
                } else {
                    g.setColor(new Color(255, 0, 0)); // 红��
                }
                g.fillRect(x, y, currentWidth, barHeight);

                // 为玩家添加血量数字显示
                if (tank.isPlayer()) {
                    String healthText = tank.getHealth() + "/" + tank.getMaxHealth();
                    g.setFont(new Font("Arial", Font.BOLD, 14));

                    // 绘制文字阴影（黑色描边）
                    g.setColor(Color.BLACK);
                    for (int offsetX = -1; offsetX <= 1; offsetX++) {
                        for (int offsetY = -1; offsetY <= 1; offsetY++) {
                            if (offsetX != 0 || offsetY != 0) {
                                g.drawString(healthText, x + offsetX, y - offsetY);
                            }
                        }
                    }

                    // 根据血量比例设置文字颜色
                    float ratio = (float)tank.getHealth() / tank.getMaxHealth();
                    if (ratio > 0.7f) {
                        g.setColor(new Color(0, 255, 0)); // 绿色
                    } else if (ratio > 0.3f) {
                        g.setColor(new Color(255, 255, 0)); // 黄色
                    } else {
                        g.setColor(new Color(255, 100, 100)); // 浅红色
                    }

                    // 绘制彩色文字
                    g.drawString(healthText, x, y);
                }
            }
        }
    }

    /**
     * 生成敌方坦克
     */
    private void spawnEnemyTank() {
        if (enemyCount >= maxEnemies) return;

        int x, y;
        boolean validPosition;

        // 在地图上方随机位置生成敌方坦克
        do {
            x = 64 + random.nextInt((WIDTH - 128) / 32) * 32;
            y = 64;
            validPosition = true;

            // 检查是否与其他坦克重叠
            Rectangle newTankArea = new Rectangle(x - 32, y - 32, 96, 96);
            for (Tank tank : tanks) {
                if (newTankArea.intersects(new Rectangle(tank.getX(), tank.getY(), tank.getWidth(), tank.getWidth()))) {
                    validPosition = false;
                    break;
                }
            }

            // 检查是否与墙��重叠
            for (Wall wall : walls) {
                if (newTankArea.intersects(new Rectangle(wall.getX(), wall.getY(), wall.getWidth(), wall.getWidth()))) {
                    validPosition = false;
                    break;
                }
            }
        } while (!validPosition);

        // 创建新的敌方坦克
        Tank enemyTank = new Tank(x, y, Direction.DOWN, false);
        enemyTank.setPlayerTank(playerTank); // 设置玩家坦克引用
        tanks.add(enemyTank);
        enemyCount++;
    }

    public void update() {
        if (gameState != GameState.PLAYING) return;

        // 生成敌方坦克
        if (random.nextInt(300) < 2 && enemyCount < maxEnemies) { // 降低生成频率
            spawnEnemyTank();
        }

        // 更新所有游戏对象
        // ...existing update code...
    }

    /**
     * 绘制��戏HUD（抬头显示）
     */
    private void drawHUD(Graphics2D g) {
        // 设置半透明黑色背景
        g.setColor(new Color(0, 0, 0, 150));
        g.fillRect(10, 10, 200, 100);

        // 设置文字颜色和字体
        g.setFont(new Font("微软雅黑", Font.BOLD, 16));

        // 显示玩家信息
        int y = 35;
        int x = 20;

        // 显示分数
        g.setColor(Color.WHITE);
        g.drawString("分数: " + score, x, y);

        // 显示剩余敌人
        y += 20;
        g.setColor(Color.RED);
        g.drawString("剩余敌人: " + (maxEnemies - enemiesDestroyed) + "/" + maxEnemies, x, y);

        // 显示当前场上敌人数量
        y += 20;
        g.setColor(Color.ORANGE);
        g.drawString("当前敌人: " + enemyCount, x, y);

        // 在屏幕右上角显示控制说明
        String[] controls = {
            "方向键 - 移动",
            "空格键 - 开火",
            "Q键 - 退出游戏"
        };

        g.setColor(new Color(0, 0, 0, 150));
        g.fillRect(WIDTH - 150, 10, 140, 80);

        g.setFont(new Font("微软雅黑", Font.PLAIN, 14));
//        g.setColor(Color.WHITE);
        y = 30;
        for (String control : controls) {
            g.drawString(control, WIDTH - 140, y);
            y += 20;
        }

        // 绘制血量条
        drawHealthBar(g, playerTank);
    }

    /**
     * 绘制坦克血量条
     */
    private void drawHealthBar(Graphics2D g, Tank tank) {
        if (!tank.isPlayer() || !tank.isActive()) return;

        int barWidth = 180;
        int barHeight = 15;
        int x = 10;
        int y = 90;

        // 绘制血条背景
        g.setColor(new Color(0, 0, 0, 150));
        g.fillRect(x, y, barWidth + 4, barHeight + 4);

        // 绘制血条底色
        g.setColor(new Color(100, 0, 0));
        g.fillRect(x + 2, y + 2, barWidth, barHeight);

        // 计算当前血量比例
        float healthRatio = (float) tank.getHealth() / tank.getMaxHealth();
        int currentWidth = (int) (barWidth * healthRatio);

        // 根据血量设置颜色
        if (healthRatio > 0.7f) {
            g.setColor(Color.GREEN);
        } else if (healthRatio > 0.3f) {
            g.setColor(Color.YELLOW);
        } else {
            g.setColor(Color.RED);
        }

        // 绘制当前血量
        g.fillRect(x + 2, y + 2, currentWidth, barHeight);

        // 显示具体血量数值
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑", Font.BOLD, 12));
        String healthText = tank.getHealth() + "/" + tank.getMaxHealth();
        g.drawString(healthText, x + barWidth / 2 - 15, y + barHeight - 2);
    }
}

